package com.echo.service;

import com.echo.dao.ArticleCategoryRelationDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * 文章分类关系服务类，处理文章和分类关系的业务逻辑
 */
public class ArticleCategoryRelationService {
    private static final Logger logger = LoggerFactory.getLogger(ArticleCategoryRelationService.class);
    private ArticleCategoryRelationDao relationDao = new ArticleCategoryRelationDao();
    
    /**
     * 为文章添加分类关联
     */
    public boolean addCategoryToArticle(Integer articleId, Integer categoryId) {
        // 检查关系是否已存在
        if (relationDao.existsRelation(articleId, categoryId)) {
            logger.warn("文章分类关系已存在，文章ID: {}, 分类ID: {}", articleId, categoryId);
            return false;
        }
        
        // 创建关系
        com.echo.entity.ArticleCategoryRelation relation = new com.echo.entity.ArticleCategoryRelation();
        relation.setArticleId(articleId);
        relation.setCategoryId(categoryId);
        
        int relationId = relationDao.insert(relation);
        if (relationId > 0) {
            logger.info("添加文章分类关系成功，文章ID: {}, 分类ID: {}", articleId, categoryId);
            return true;
        } else {
            logger.error("添加文章分类关系失败，文章ID: {}, 分类ID: {}", articleId, categoryId);
            return false;
        }
    }
    
    /**
     * 批量为文章添加分类关联（先删除旧关系，再添加新关系）
     */
    public boolean batchAddCategoriesToArticle(Integer articleId, List<Integer> categoryIds) {
        System.out.println("=== ArticleCategoryRelationService.batchAddCategoriesToArticle 被调用 ===");
        System.out.println("文章ID: " + articleId);
        System.out.println("分类ID列表: " + categoryIds);
        
        // 开始事务性操作
        // 1. 先删除文章的所有旧分类关系
        System.out.println("步骤1: 删除文章的所有旧分类关系");
        int deleteCount = relationDao.deleteByArticleId(articleId);
        System.out.println("删除旧关系数量: " + deleteCount);
        
        // 2. 添加新的分类关系
        if (categoryIds != null && !categoryIds.isEmpty()) {
            System.out.println("步骤2: 添加新的分类关系");
            int insertCount = relationDao.batchInsert(articleId, categoryIds);
            System.out.println("批量添加文章分类关系完成，添加分类数量: " + insertCount);
            logger.info("批量添加文章分类关系完成，文章ID: {}, 添加分类数量: {}", articleId, insertCount);
            return true;
        } else {
            System.out.println("文章未关联任何分类");
            logger.info("文章未关联任何分类，文章ID: {}", articleId);
            return true;
        }
    }
    
    /**
     * 从文章中移除分类关联
     */
    public boolean removeCategoryFromArticle(Integer articleId, Integer categoryId) {
        // 检查关系是否存在
        if (!relationDao.existsRelation(articleId, categoryId)) {
            logger.warn("文章分类关系不存在，无法移除，文章ID: {}, 分类ID: {}", articleId, categoryId);
            return false;
        }
        
        // 由于我们使用的是软删除，这里可以通过其他方式实现，但为了简化，我们使用现有的方法
        // 注意：这里没有直接删除单个关系的方法，实际应用中可能需要在DAO层添加
        logger.warn("当前实现不支持删除单个关系，请使用批量更新方法");
        return false;
    }
    
    /**
     * 获取文章的所有分类ID
     */
    public List<Integer> getArticleCategoryIds(Integer articleId) {
        List<Integer> categoryIds = relationDao.findCategoryIdsByArticleId(articleId);
        logger.info("获取文章分类ID列表，文章ID: {}, 分类数量: {}", articleId, categoryIds.size());
        return categoryIds;
    }
    
    /**
     * 获取分类下的所有文章ID
     */
    public List<Integer> getCategoryArticleIds(Integer categoryId) {
        List<Integer> articleIds = relationDao.findArticleIdsByCategoryId(categoryId);
        logger.info("获取分类文章ID列表，分类ID: {}, 文章数量: {}", categoryId, articleIds.size());
        return articleIds;
    }
    
    /**
     * 检查分类下是否有文章
     */
    public boolean hasArticles(Integer categoryId) {
        List<Integer> articleIds = relationDao.findArticleIdsByCategoryId(categoryId);
        return !articleIds.isEmpty();
    }
    
    /**
     * 检查文章是否关联了指定分类
     */
    public boolean isArticleInCategory(Integer articleId, Integer categoryId) {
        boolean exists = relationDao.existsRelation(articleId, categoryId);
        logger.info("检查文章是否在分类中，文章ID: {}, 分类ID: {}, 结果: {}", articleId, categoryId, exists);
        return exists;
    }
}